﻿namespace MailChimp

open System
open MailChimp.Types
open MailChimp.Types.Mandrill

[<Sealed>]
/// <summary>Mandrill API wrapper.</summary>
type MandrillApi =
    inherit ApiBase

    new : apiKey:string -> MandrillApi

    //------------------------------------------------------------------------------
    //  (*) Custom API call
    //------------------------------------------------------------------------------

    /// <summary>Executes a custom call to the Mandrill server.</summary>
    /// <param name="methodName">Method name.</param>
    /// <param name="p">[optional] Input data.</param>
    /// <returns>Deserialized result.</returns>
    member CallServer : methodName:string * p:Input opt -> 'T

    //------------------------------------------------------------------------------
    //  Users related methods
    //------------------------------------------------------------------------------

    /// <summary>Validate an API key and respond to a ping.</summary>
    /// <remarks>Users section.</remarks>
    /// <returns>"PONG" if everything is ok.</returns>
    member Ping : unit -> string

    /// <summary>Returns the information about the API-connected user.</summary>
    /// <remarks>Users section.</remarks>
    /// <returns>The user information including username, key, reputation, quota,
    /// and historical sending stats.</returns>
    member UserInfo : unit -> UserInfo

    /// <summary>Returns the senders that have tried to use this account,
    /// both verified and unverified.</summary>
    /// <remarks>Users section.</remarks>
    /// <returns>A list of sender data, one for each sending addresses used by the account.</returns>
    member Senders : unit -> MVList<SenderInfo>

    //------------------------------------------------------------------------------
    //  Messages related methods
    //------------------------------------------------------------------------------

    /// <summary>Sends a new transactional message through Mandrill.</summary>
    /// <remarks>Messages section.
    /// <para>C# specific optional parameters.</para></remarks>
    /// <param name="message">The information on the message to send.</param>
    /// <param name="async">[optional] Enables background sending mode
    /// that is optimized for bulk sending.</param>
    /// <returns>Sending status for each email address.</returns>
    member Send : message:Messages.Message * async:bool opt -> MVList<Messages.SendResult>

    /// <summary>Sends a new transactional message through Mandrill.</summary>
    /// <remarks>Messages section.
    /// <para>F# specific optional parameters.</para></remarks>
    /// <param name="message">The information on the message to send.</param>
    /// <param name="async">[optional] Enables background sending mode
    /// that is optimized for bulk sending.</param>
    /// <returns>Sending status for each email address.</returns>
    member Send : message:Messages.Message * ?async:bool -> MVList<Messages.SendResult>

    /// <summary>Sends a new transactional message through Mandrill using a template.</summary>
    /// <remarks>Messages section.
    /// <para>C# specific optional parameters.</para></remarks>
    /// <param name="templateName">The name of a template that exists in the user's account.</param>
    /// <param name="templateContent">A sequence of template content to send.</param>
    /// <param name="message">The information on the message to send.</param>
    /// <param name="async">[optional] Enables background sending mode
    /// that is optimized for bulk sending.</param>
    /// <returns>Sending status for each email address.</returns>
    member SendTemplate : templateName:string * templateContent:NameContentList<string> *
        Messages.Message * async:bool opt -> MVList<Messages.SendResult>

    /// <summary>Sends a new transactional message through Mandrill using a template.</summary>
    /// <remarks>Messages section.
    /// <para>F# specific optional parameters.</para></remarks>
    /// <param name="templateName">The name of a template that exists in the user's account.</param>
    /// <param name="templateContent">A sequence of template content to send.</param>
    /// <param name="message">The information on the message to send.</param>
    /// <param name="async">[optional] Enables background sending mode
    /// that is optimized for bulk sending.</param>
    /// <returns>Sending status for each email address.</returns>
    member SendTemplate : templateName:string * templateContent:NameContentList<string> *
        Messages.Message * ?async:bool -> MVList<Messages.SendResult>

    /// <summary>Takes a raw MIME document for a message, and sends it
    /// exactly as if it were sent over the SMTP protocol.</summary>
    /// <remarks>Messages section.
    /// <para>C# specific optional parameters.</para></remarks>
    /// <param name="message">The full MIME document of an email message.</param>
    /// <param name="fromEmail">[optional] Defines the sender address -
    /// otherwise the address found in the provided headers will be used.</param>
    /// <param name="fromName">[optional] The sender alias.</param>
    /// <param name="toEmails">[optional] A list of recipients to receive the message -
    /// otherwise the To, Cc, and Bcc headers provided in the document will be used.</param>
    /// <param name="async">[optional] Enables background sending mode
    /// that is optimized for bulk sending.</param>
    /// <returns>Sending status for each email address.</returns>
    member SendRaw : message:string * fromEmail:string opt * fromName:string opt *
        toEmails:string seq opt * async:bool opt -> MVList<Messages.SendResult>

    /// <summary>Takes a raw MIME document for a message, and sends it
    /// exactly as if it were sent over the SMTP protocol.</summary>
    /// <remarks>Messages section.
    /// <para>F# specific optional parameters.</para></remarks>
    /// <param name="message">The full MIME document of an email message.</param>
    /// <param name="fromEmail">[optional] Defines the sender address -
    /// otherwise the address found in the provided headers will be used.</param>
    /// <param name="fromName">[optional] The sender alias.</param>
    /// <param name="toEmails">[optional] A lits of the recipients to receive the message -
    /// otherwise the To, Cc, and Bcc headers provided in the document will be used.</param>
    /// <param name="async">[optional] Enables background sending mode
    /// that is optimized for bulk sending.</param>
    /// <returns>Sending status for each email address.</returns>
    member SendRaw : message:string * ?fromEmail:string * ?fromName:string *
        ?toEmails:string seq * ?async:bool -> MVList<Messages.SendResult>

    /// <summary>Parse the full MIME document for an email message,
    /// returning the content of the message broken into its constituent pieces.</summary>
    /// <remarks>Messages section.</remarks>
    /// <param name="message">The full MIME document of an email message.</param>
    /// <returns>The parsed messag.</returns>
    member Parse : message:string -> Messages.ParsedMessage

    /// <summary>Searches the content of recently sent messages and
    /// optionally narrow by date range, tags and senders.</summary>
    /// <remarks>Messages section.
    /// <para>C# specific optional parameters.</para></remarks>
    /// <param name="query">The search terms to find matching messages for.</param>
    /// <param name="dateFrom">[optional] Start date.</param>
    /// <param name="dateTo">[optional] End date.</param>
    /// <param name="tags">[optional] An array of tag names to narrow the search to,
    /// will return messages that contain ANY of the tags.</param>
    /// <param name="senders">[optional] An array of sender addresses to narrow the search to,
    /// will return messages sent by ANY of the senders.</param>
    /// <param name="limit">[optional] The maximum number of results to return,
    /// <para>Defaults to 100, 1000 is the maximum.</para></param>
    /// <returns>The list of matching messages.</returns>
    member MessagesSearch : query:string * dateFrom:DateTime opt * dateTo:DateTime opt *
        tags:string seq opt * senders:string seq opt * limit:int opt -> MVList<Messages.SearchResult>

    /// <summary>Searches the content of recently sent messages and
    /// optionally narrow by date range, tags and senders.</summary>
    /// <remarks>Messages section.
    /// <para>F# specific optional parameters.</para></remarks>
    /// <param name="query">The search terms to find matching messages for.</param>
    /// <param name="dateFrom">[optional] Start date.</param>
    /// <param name="dateTo">[optional] End date.</param>
    /// <param name="tags">[optional] An array of tag names to narrow the search to,
    /// will return messages that contain ANY of the tags.</param>
    /// <param name="senders">[optional] An array of sender addresses to narrow the search to,
    /// will return messages sent by ANY of the senders.</param>
    /// <param name="limit">[optional] The maximum number of results to return,
    /// <para>Defaults to 100, 1000 is the maximum.</para></param>
    /// <returns>The list of matching messages.</returns>
    member MessagesSearch : query:string * ?dateFrom:DateTime * ?dateTo:DateTime *
        ?tags:string seq * ?senders:string seq * ?limit:int -> MVList<Messages.SearchResult>

    //------------------------------------------------------------------------------
    //  Tags related methods
    //------------------------------------------------------------------------------

    /// <summary>Returns all of the user-defined tag information.</summary>
    /// <remarks>Tags section.</remarks>
    /// <returns>A list of user-defined tags.</returns>
    member TagsList : unit -> MVList<TagInfo>

    /// <summary>Returns more detailed information about a single tag,
    /// including aggregates of recent stats.</summary>
    /// <remarks>Tags section.</remarks>
    /// <param name="tag">An existing tag name.</param>
    /// <returns>The detailed information on the tag.</returns>
    member TagInfo : tag:string -> TagInfo

    /// <summary>Returns the recent history (hourly stats for the last 30 days) for a tag.</summary>
    /// <remarks>Tags section.
    /// <para>If no parameter was supplied, returns the recent history for all tags.</para>
    /// <para>C# specific optional parameters.</para></remarks>
    /// <param name="tag">[optional] An existing tag name.</param>
    /// <returns>The list of history information.</returns>
    member TagsTimeSeries : tag:string opt -> MVList<Stats>

    /// <summary>Returns the recent history (hourly stats for the last 30 days) for a tag.</summary>
    /// <remarks>Tags section.
    /// <para>If no parameter was supplied, returns the recent history for all tags.</para>
    /// <para>F# specific optional parameters.</para></remarks>
    /// <param name="tag">[optional] An existing tag name.</param>
    /// <returns>The list of history information.</returns>
    member TagsTimeSeries : ?tag:string -> MVList<Stats>

    //------------------------------------------------------------------------------
    //  Senders related methods
    //------------------------------------------------------------------------------

    /// <summary>Returns the senders that have tried to use this account.</summary>
    /// <remarks>Senders section.</remarks>
    /// <returns>A list of sender data, one for each sending addresses used by the account.</returns>
    member SendersList : unit -> MVList<SenderInfo>

    /// <summary>Returnss the sender domains that have been added to this account.</summary>
    /// <remarks>Senders section.</remarks>
    /// <returns>A list of sender domain data, one for each sending domain used by the account.</returns>
    member SendersDomains : unit -> MVList<Domain>

    /// <summary>Returns more detailed information about a single sender,
    /// including aggregates of recent stats</summary>
    /// <remarks>Senders section.</remarks>
    /// <param name="address">The email address of the sender.</param>
    /// <returns>The detailed information on the sender.</returns>
    member SenderInfo : address:string -> SenderInfo

    /// <summary>Returns the recent history (hourly stats for the last 30 days) for a sender.</summary>
    /// <remarks>Senders section.</remarks>
    /// <param name="address">The email address of the sender.</param>
    /// <returns>The list of history information.</returns>
    member SendersTimeSeries : address:string -> MVList<Stats>

    //------------------------------------------------------------------------------
    //  Blacklist related methods
    //------------------------------------------------------------------------------

    /// <summary>Retrieves your email rejection blacklist.</summary>
    /// <remarks>Rejects section.
    /// <para>C# specific optional parameters.</para></remarks>
    /// <param name="email">[optional] An email address or prefix to search by.</param>
    /// <param name="includeExpired">[optional] Whether to include rejections
    /// that have already expired.</param>
    /// <returns>The information for each rejection blacklist entry (up to 1000 items).</returns>
    member Blacklist : email:string opt * includeExpired:bool opt -> MVList<Rejections.BlacklistItem>

    /// <summary>Retrieves your email rejection blacklist.</summary>
    /// <remarks>Blacklist section.
    /// <para>F# specific optional parameters.</para></remarks>
    /// <param name="email">[optional] An email address or prefix to search by.</param>
    /// <param name="includeExpired">[optional] Whether to include rejections
    /// that have already expired.</param>
    /// <returns>The information for each rejection blacklist entry (up to 1000 items).</returns>
    member Blacklist : ?email:string * ?includeExpired:bool -> MVList<Rejections.BlacklistItem>

    /// <summary>Adds an email to an email rejection blacklist.</summary>
    /// <remarks>Blacklist section.
    /// <para> Addresses that you add manually will never expire and there is no
    /// reputation penalty for removing them from your blacklist.</para>
    /// <para>Attempting to blacklist an address that has been whitelisted will
    /// have no effect.</para></remarks>
    /// <param name="email">An email address to add to the blacklist.</param>
    /// <returns>True on success.</returns>
    member BlacklistAdd : email:string -> bool

    /// <summary>Removes an email address from the blacklist.</summary>
    /// <remarks>Blacklist section.
    /// <para>There is no limit to how many rejections you can remove from your blacklist,</para>
    /// <para>but keep in mind that each deletion has an affect on your reputation.</para></remarks>
    /// <param name="email">An email address to remove from the blacklist.</param>
    /// <returns>True on success.</returns>
    member BlacklistDel : email:string -> bool

    //------------------------------------------------------------------------------
    //  Whitelist related methods
    //------------------------------------------------------------------------------

    /// <summary>Retrieves your email rejection whitelist.</summary>
    /// <remarks>Whitelist section.</remarks>
    /// <param name="email">[optional] An email address or prefix to search by.</param>
    /// <returns>The information for each rejection whitelist entry (up to 1000 items).</returns>
    member Whitelist : email:string opt -> MVList<Rejections.WhitelistItem>

    /// <summary>Adds an email to an email rejection whitelist.</summary>
    /// <remarks>Whitelist section.
    /// <para>If the address is currently on your blacklist, that blacklist entry
    /// will be removed automatically.</para></remarks>
    /// <param name="email">An email address to add to the whitelist.</param>
    /// <returns>True on success.</returns>
    member WhitelistAdd : email:string -> bool

    /// <summary>Removes an email address from the whitelist.</summary>
    /// <remarks>Whitelist section.</remarks>
    /// <param name="email">An email address to remove from the whitelist.</param>
    /// <returns>True on success.</returns>
    member WhitelistDel : email:string -> bool

    //------------------------------------------------------------------------------
    //  Urls related methods
    //------------------------------------------------------------------------------

    /// <summary>Gets the 100 most clicked URLs.</summary>
    /// <remarks>Urls section.</remarks>
    /// <returns>The 100 most clicked URLs and their stats.</returns>
    member UrlsList : unit -> MVList<UrlInfo>

    /// <summary>Returns the 100 most clicked URLs that match the given search query.</summary>
    /// <remarks>Urls section.</remarks>
    /// <param name="query">A search query.</param>
    /// <returns>The 100 most clicked URLs matching the search query.</returns>
    member UrlsSearch : query:string -> MVList<UrlInfo>

    /// <summary>Return the recent history (hourly stats for the last 30 days) for a url.</summary>
    /// <remarks>Urls section.</remarks>
    /// <param name="url">An existing url.</param>
    /// <returns>The list of history information.</returns>
    member UrlsTimeSeries : url:string -> MVList<UrlStats>

    //------------------------------------------------------------------------------
    //  Templates related methods
    //------------------------------------------------------------------------------

    /// <summary>Returns a list of all the templates available to this user.</summary>
    /// <remarks>Templates section.</remarks>
    /// <returns>A list of information about each template.</returns>
    member TemplatesList : unit -> MVList<TemplateInfo>

    /// <summary>Gets the information for an existing template.</summary>
    /// <remarks>Templates section.</remarks>
    /// <param name="name">The name of an existing template.</param>
    /// <returns>The requested template information.</returns>
    member TemplateInfo : name:string -> TemplateInfo

    /// <summary>Adds a new template.</summary>
    /// <remarks>Templates section.
    /// <para>C# specific optional parameters.</para></remarks>
    /// <param name="name">The name for the new template - must be unique.</param>
    /// <param name="code">The HTML code for the template with
    /// mc:edit attributes for the editable elements.</param>
    /// <param name="publish">[optional] Flag indicating whether to add a draft
    /// template without publishing.</param>
    /// <returns>The information about the new template.</returns>
    member TemplateAdd : name:string * code:string * publish:bool opt -> TemplateInfo

    /// <summary>Adds a new template.</summary>
    /// <remarks>Templates section.
    /// <para>F# specific optional parameters.</para></remarks>
    /// <param name="name">The name for the new template - must be unique.</param>
    /// <param name="code">The HTML code for the template with
    /// mc:edit attributes for the editable elements.</param>
    /// <param name="publish">[optional] Flag indicating whether to add a draft
    /// template without publishing.</param>
    /// <returns>The information about the new template.</returns>
    member TemplateAdd : name:string * code:string * ?publish:bool -> TemplateInfo

    /// <summary>Updates the code for an existing template.</summary>
    /// <remarks>Templates section.
    /// <para>C# specific optional parameters.</para></remarks>
    /// <param name="name">The name of an existing template.</param>
    /// <param name="code">The HTML code for the template with
    /// mc:edit attributes for the editable elements.</param>
    /// <param name="publish">[optional] Flag indicating whether to update the draft
    /// version of the template without publishing.</param>
    /// <returns>The template that was updated.</returns>
    member TemplateUpdate : name:string * code:string * publish:bool opt -> TemplateInfo

    /// <summary>Updates the code for an existing template.</summary>
    /// <remarks>Templates section.
    /// <para>F# specific optional parameters.</para></remarks>
    /// <param name="name">The name of an existing template.</param>
    /// <param name="code">The HTML code for the template with
    /// mc:edit attributes for the editable elements.</param>
    /// <param name="publish">[optional] Flag indicating whether to update the draft
    /// version of the template without publishing.</param>
    /// <returns>The template that was updated.</returns>
    member TemplateUpdate : name:string * code:string * ?publish:bool -> TemplateInfo

    /// <summary>Publish the content for the template.
    /// <para>Any new messages sent using this template will start using
    /// the content that was previously in draft.</para></summary>
    /// <remarks>Templates section.</remarks>
    /// <param name="name">The name of an existing template.</param>
    /// <returns>The template that was deleted.</returns>
    member TemplatePublish : name:string -> TemplateInfo

    /// <summary>Deletes a template.</summary>
    /// <remarks>Templates section.</remarks>
    /// <param name="name">The name of an existing template.</param>
    /// <returns>The template that was deleted.</returns>
    member TemplateDel : name:string -> TemplateInfo

    /// <summary>Injects content and optionally merge fields into a template,
    /// returning the resulting HTML.</summary>
    /// <remarks>Templates section.
    /// <para>C# specific optional parameters.</para></remarks>
    /// <param name="templateName">The name of an existing template.</param>
    /// <param name="templateContent">A sequence of template content to send.</param>
    /// <param name="mergeVars">[optional] Merge variables to use for injecting merge
    /// field content. If this is not provided, no merge fields will be replaced.</param>
    /// <returns>The result of rendering the given template
    /// with the contentand merge field values injected.</returns>
    member TemplateRender : templateName:string * templateContent:NameContentList<string> *
        mergeVars:NameContentList<string> opt -> string

    /// <summary>Injects content and optionally merge fields into a template,
    /// returning the resulting HTML.</summary>
    /// <remarks>Templates section.
    /// <para>F# specific optional parameters.</para></remarks>
    /// <param name="templateName">The name of an existing template.</param>
    /// <param name="templateContent">A sequence of template content to send.</param>
    /// <param name="mergeVars">[optional] Merge variables to use for injecting merge
    /// field content. If this is not provided, no merge fields will be replaced.</param>
    /// <returns>The result of rendering the given template
    /// with the contentand merge field values injected.</returns>
    member TemplateRender : templateName:string * templateContent:NameContentList<string> *
        ?mergeVars:NameContentList<string> -> string

    /// <summary>Returns the recent history (hourly stats for the last 30 days) for a template.</summary>
    /// <remarks>Templates section.</remarks>
    /// <param name="name">The name of an existing template.</param>
    /// <returns>The list of history information.</returns>
    member TemplatesTimeSeries : name:string -> MVList<Stats>

    //------------------------------------------------------------------------------
    //  Webhooks related methods
    //------------------------------------------------------------------------------

    /// <summary>Gets the list of all webhooks defined on the account.</summary>
    /// <remarks>Webhooks section.</remarks>
    /// <returns>The webhooks associated with the account.</returns>
    member WebhooksList : unit -> MVList<WebhookInfo>

    /// <summary>Returns the data about an existing webhook.</summary>
    /// <remarks>Webhooks section.</remarks>
    /// <param name="id">The unique identifier of a webhook belonging to this account.</param>
    /// <returns>The information about the webhook.</returns>
    member WebhookInfo : id:int -> WebhookInfo

    /// <summary>Adds a new webhook.</summary>
    /// <remarks>Webhooks section.
    /// <para>C# specific optional parameters.</para></remarks>
    /// <param name="url">The URL to POST batches of events.</param>
    /// <param name="description">[optional] a description of the webhook.</param>
    /// <param name="events">[optional] A list of events that will be posted to the webhook.</param>
    /// <returns>The information about the new webhook.</returns>
    member WebhookAdd : url:string * description:string opt * events:EventType seq opt -> WebhookInfo

    /// <summary>Adds a new webhook.</summary>
    /// <remarks>Webhooks section.
    /// <para>F# specific optional parameters.</para></remarks>
    /// <param name="url">The URL to POST batches of events.</param>
    /// <param name="description">[optional] a description of the webhook.</param>
    /// <param name="events">[optional] A list of events that will be posted to the webhook.</param>
    /// <returns>The information about the new webhook.</returns>
    member WebhookAdd : url:string * ?description:string * ?events:EventType seq -> WebhookInfo

    /// <summary>Updates an existing webhook.</summary>
    /// <remarks>Webhooks section.
    /// <para>C# specific optional parameters.</para></remarks>
    /// <param name="id">The unique identifier of a webhook belonging to this account.</param>
    /// <param name="url">The URL to POST batches of events.</param>
    /// <param name="description">[optional] a description of the webhook.</param>
    /// <param name="events">[optional] A list of events that will be posted to the webhook.</param>
    /// <returns>The information for the updated webhook.</returns>
    member WebhookUpdate : id:int * url:string * description:string opt *
        events:EventType seq opt -> WebhookInfo

    /// <summary>Updates an existing webhook.</summary>
    /// <remarks>Webhooks section.
    /// <para>F# specific optional parameters.</para></remarks>
    /// <param name="id">The unique identifier of a webhook belonging to this account.</param>
    /// <param name="url">The URL to POST batches of events.</param>
    /// <param name="description">[optional] a description of the webhook.</param>
    /// <param name="events">[optional] A list of events that will be posted to the webhook.</param>
    /// <returns>The information for the updated webhook.</returns>
    member WebhookUpdate : id:int * url:string * ?description:string *
        ?events:EventType seq -> WebhookInfo

    /// <summary>Deletes an existing webhook.</summary>
    /// <remarks>Webhooks section.</remarks>
    /// <param name="id">The unique identifier of a webhook belonging to this account.</param>
    /// <returns>The information for the deleted webhook.</returns>
    member WebhookDel : id:int -> WebhookInfo

    //------------------------------------------------------------------------------
    //  Inbound related methods
    //------------------------------------------------------------------------------

    /// <summary>Gets the list of the domains configured for inbound delivery.</summary>
    /// <remarks>Inbound section.</remarks>
    /// <returns>The inbound domains associated with the account.</returns>
    member InboundDomains : unit -> MVList<Domain>

    /// <summary>Gets the list of the mailbox routes defined for an inbound domain.</summary>
    /// <remarks>Inbound section.</remarks>
    /// <param name="domain">The domain to check.</param>
    /// <returns>The routes associated with the domain.</returns>
    member InboundRoutes : domain:string -> MVList<Inbound.Route>

    /// <summary>Takes a raw MIME document for a message, and sends it
    /// exactly as if it were sent over the SMTP protocol.</summary>
    /// <remarks>Inbound section.
    /// <para>C# specific optional parameters.</para></remarks>
    /// <param name="message">The full MIME document of an email message.</param>
    /// <param name="toEmails">[optional] A list of recipients - otherwise To, Cc, and Bcc
    /// headers provided in the document will be used.</param>
    /// <param name="mailFrom">[optional] The address specified in the MAIL FROM stage
    /// of the SMTP conversation. Required for the SPF check.</param>
    /// <param name="helo">[optional] The identification provided by the client mta in
    /// the MTA state of the SMTP conversation. Required for the SPF check.</param>
    /// <param name="clientAddress">[optional] The remote MTA's ip address.
    /// Required for the SPF check.</param>
    /// <returns>The information for each recipient in the message (usually one)
    /// that matched an inbound route.</returns>
    member InboundSendRaw : message:string * toEmails:string seq opt * mailFrom:string opt *
        helo: string opt * clientAddress:string opt -> MVList<Inbound.Recipient>

    /// <summary>Takes a raw MIME document for a message, and sends it
    /// exactly as if it were sent over the SMTP protocol.</summary>
    /// <remarks>Inbound section.
    /// <para>F# specific optional parameters.</para></remarks>
    /// <param name="message">The full MIME document of an email message.</param>
    /// <param name="toEmails">[optional] A list of recipients - otherwise To, Cc, and Bcc
    /// headers provided in the document will be used.</param>
    /// <param name="mailFrom">[optional] The address specified in the MAIL FROM stage
    /// of the SMTP conversation. Required for the SPF check.</param>
    /// <param name="helo">[optional] The identification provided by the client mta in
    /// the MTA state of the SMTP conversation. Required for the SPF check.</param>
    /// <param name="clientAddress">[optional] The remote MTA's ip address.
    /// Required for the SPF check.</param>
    /// <returns>The information for each recipient in the message (usually one)
    /// that matched an inbound route.</returns>
    member InboundSendRaw : message:string * ?toEmails:string seq * ?mailFrom:string *
        ?helo: string * ?clientAddress:string -> MVList<Inbound.Recipient>